package com.xl.juc.lock8;

import java.util.concurrent.TimeUnit;

/**
 * 8锁 就是锁的8个问题
 * 1.标准情况下，两个线程先打印发短信还是打电话？1发短信 2打电话
 * 2.sendSms延迟4s，两个线程先打印发短信还是打电话？1发短信 2打电话
 * 3.增加普通方法，两个线程先打印还是hello？1.hello 2发短信
 * 4.两个对象，两个同步方法，两个线程先打印发短信还是打电话？1电话  2发短信
 * 5.增加两个静态的同步方法，只有一个对象，两个线程先打印发短信还是打电话？1发短信 2打电话
 * 6.两个对象，两个静态的同步方法，两个线程先打印发短信还是打电话？1发短信 2打电话
 *7.1个静态的同步方法，1个普通同步方法，一个对象，两个线程先打印发短信还是打电话？1电话  2发短信
 * 静态方法锁的是class类，普通同步方法锁的对象。两把锁，所以先打电话  2发短信
 * 8.个静态的同步方法，1个普通同步方法，2个对象，两个线程先打印发短信还是打电话？1电话  2发短信
 * 静态方法锁的是class类，普通同步方法锁的对象。两把锁，所以先打电话  2发短信
 *
 * 小结：
 * new this 具体的对象(手机)
 * static class 唯一的一个模板
 *
 * @author Charley
 * @create 2020-12-27
 */
public class lock4 {
    public static void main(String[] args) {
        //static静态方法，锁的是class，Phone3 唯一的class对象，两个对象的class类模板只有一个
        Phone4 phone1 = new Phone4();
        Phone4 phone2 = new Phone4();
        new Thread(()->{
            phone1.sendSms();
        },"A").start();
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        new Thread(()->{phone2.call();},"B").start();

    }
}

//Phone3 唯一的class对象
class Phone4{
    //synchronized 锁的对象是方法的调用者 两个方法用的同一个锁，谁先拿到谁执行
    //static静态方法，类已加载就有了，不是new的对象 ，锁的是class
    //静态同步方法
    public static synchronized void sendSms(){
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }

    //普通的同步方法
    public  synchronized void call(){
        System.out.println("打电话");
    }
}
